package cn.edu.zafu.bigdata.YinMingyan.chapter10;

public class NoNeedingSynchronized {
    public static void main(String[] args) {
        singleAtom sa = new singleAtom();
         int m = sa.set(2);
        sa.set("good");
        System.out.println(m);
        Point p = new Point();


    }
}

class Counter3 {
        public static final Object lock = new Object();
}

class singleAtom{
    private int value = 0;
    public String str = "";
    //单条原子操作的语句不需要同步
    public int set(int m) {
        synchronized (Counter3.lock) {
            this.value = m;
        }
        return m;
    }

    //引用不需要同步
    public void set(String s) {
        this.str = s;
        System.out.println(this.str);
    }
}

    //如果是多行赋值语句，就必须保证是同步操作,读也需要同步
    class Point {
        int x;
        int y;

        public void set(int x, int y) {
            synchronized(this) {
                this.x = x;
                this.y = y;
            }
            System.out.println(this.x+this.y);
        }

        public int[] get() {
            int[] copy = new int[2];
            copy[0] = x;
            copy[1] = y;
            return copy;
        }

        //把非原子操作变为原子操作
//        class Point {
//            int[] ps;
//            public void set(int x, int y) {
//                int[] ps = new int[] { x, y }; //这里的ps是方法内部定义的局部变量，每个线程都会有各自的局部变量，互不影响，并且互不可见，并不需要同步。
//                this.ps = ps; //引用赋值的原子操作
//            }
//        }
        //不过，读方法在复制int[]数组的过程中仍然需要同步。

    }

